home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / !Interfaces / Universal Interfaces 2.0a1 / PInterfaces / PPCToolbox.p < prev    next >
Encoding:
Text File  |  1994-07-21  |  14.6 KB  |  485 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        PPCToolbox.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a1.1  ETO #15, MPW prerelease.  Sunday, July 17, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT PPCToolbox;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __PPCTOOLBOX__}
  27. {$SETC __PPCTOOLBOX__ := 1}
  28.  
  29. {$I+}
  30. {$SETC PPCToolboxIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __APPLETALK__}
  35. {$I AppleTalk.p}
  36. {$ENDC}
  37. {    Types.p                                                        }
  38. {        ConditionalMacros.p                                        }
  39. {    OSUtils.p                                                    }
  40. {        MixedMode.p                                                }
  41.  
  42. {$IFC UNDEFINED __MEMORY__}
  43. {$I Memory.p}
  44. {$ENDC}
  45.  
  46. {$PUSH}
  47. {$ALIGN MAC68K}
  48. {$LibExport+}
  49.     
  50. TYPE
  51. PPCServiceType = CHAR;
  52.  
  53.  
  54. CONST
  55.     ppcServiceRealTime            = 1;
  56.  
  57.     
  58. TYPE
  59. PPCLocationKind = INTEGER;
  60.  
  61.  
  62. CONST
  63.     ppcNoLocation                = 0;                            { There is no PPCLocName }
  64.     ppcNBPLocation                = 1;                            { Use AppleTalk NBP      }
  65.     ppcNBPTypeLocation            = 2;                            { Used for specifying a location name type during PPCOpen only }
  66.  
  67.     
  68. TYPE
  69. PPCPortKinds = INTEGER;
  70.  
  71.  
  72. CONST
  73.     ppcByCreatorAndType            = 1;                            { Port type is specified as colloquial Mac creator and type }
  74.     ppcByString                    = 2;                            { Port type is in pascal string format }
  75.  
  76. { Values returned for request field in PPCInform call }
  77.     
  78. TYPE
  79. PPCSessionOrigin = CHAR;
  80.  
  81.  
  82. CONST
  83. { Values returned for requestType field in PPCInform call }
  84.     ppcLocalOrigin                = 1;                            { session originated from this machine }
  85.     ppcRemoteOrigin                = 2;                            { session originated from remote machine }
  86.  
  87.     
  88. TYPE
  89. PPCPortRefNum = INTEGER;
  90.  
  91.     PPCSessRefNum = LONGINT;
  92.  
  93.     PPCPortRec = RECORD
  94.         nameScript:                ScriptCode;                                { script of name }
  95.         name:                    Str32;                                    { name of port as seen in browser }
  96.         portKindSelector:        PPCPortKinds;                            { which variant }
  97.         CASE INTEGER OF
  98.         0: (
  99.             portTypeStr:                Str32;                                { pascal type string }
  100.            );
  101.         1: (
  102.             portCreator:                OSType;
  103.             portType:                    OSType;
  104.            );
  105.     END;
  106.  
  107.     PPCPortPtr = ^PPCPortRec;
  108.  
  109.     LocationNameRec = RECORD
  110.         locationKindSelector:    PPCLocationKind;                        { which variant }
  111.         CASE INTEGER OF
  112.         0: (
  113.             nbpEntity:                    EntityName;                            { NBP name entity }
  114.            );
  115.         1: (
  116.             nbpType:                    Str32;                                { just the NBP type string, for PPCOpen }
  117.            );
  118.     END;
  119.  
  120.     LocationNamePtr = ^LocationNameRec;
  121.  
  122.     PortInfoRec = RECORD
  123.         filler1:                SInt8;
  124.         authRequired:            BOOLEAN;
  125.         name:                    PPCPortRec;
  126.     END;
  127.     PortInfoPtr = ^PortInfoRec;
  128.  
  129.     PortInfoArrayPtr = ^PortInfoRec;
  130.  
  131.     PPCParamBlockPtr = ^PPCParamBlockRec;
  132.  
  133.     PPCCompProcPtr = ProcPtr;  { PROCEDURE PPCComp(pb: PPCParamBlockPtr); }
  134.     PPCCompUPP = UniversalProcPtr;
  135.  
  136.     PPCOpenPBRec = PACKED RECORD
  137.         qLink:                    Ptr;
  138.         csCode:                    INTEGER;
  139.         intUse:                    INTEGER;
  140.         intUsePtr:                Ptr;
  141.         ioCompletion:            PPCCompUPP;
  142.         ioResult:                OSErr;
  143.         Reserved:                ARRAY [0..4] OF LONGINT;
  144.         portRefNum:                PPCPortRefNum;                            { 38 <--   Port Reference }
  145.         filler1:                LONGINT;
  146.         serviceType:            PPCServiceType;                            { 44 -->    Bit field describing the requested port service }
  147.         resFlag:                UInt8;                                    { Must be set to 0 }
  148.         portName:                PPCPortPtr;                                { 46 -->   PortName for PPC }
  149.         locationName:            LocationNamePtr;                        { 50 -->   If NBP Registration is required }
  150.         networkVisible:            BOOLEAN;                                { 54 -->   make this network visible on network }
  151.         nbpRegistered:            BOOLEAN;                                { 55 <--   The given location name was registered on the network }
  152.     END;
  153.     PPCOpenPBPtr = ^PPCOpenPBRec;
  154.  
  155.     PPCInformPBRec = PACKED RECORD
  156.         qLink:                    Ptr;
  157.         csCode:                    INTEGER;
  158.         intUse:                    INTEGER;
  159.         intUsePtr:                Ptr;
  160.         ioCompletion:            PPCCompUPP;
  161.         ioResult:                OSErr;
  162.         Reserved:                ARRAY [0..4] OF LONGINT;
  163.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  164.         sessRefNum:                PPCSessRefNum;                            { 40 <--   Session Reference }
  165.         serviceType:            PPCServiceType;                            { 44 <--   Status Flags for type of session, local, remote }
  166.         autoAccept:                BOOLEAN;                                { 45 -->   if true session will be accepted automatically }
  167.         portName:                PPCPortPtr;                                { 46 -->   Buffer for Source PPCPortRec }
  168.         locationName:            LocationNamePtr;                        { 50 -->   Buffer for Source LocationNameRec }
  169.         userName:                StringPtr;                                { 54 -->   Buffer for Soure user's name trying to link. }
  170.         userData:                LONGINT;                                { 58 <--   value included in PPCStart's userData }
  171.         requestType:            PPCSessionOrigin;                        { 62 <--   Local or Network }
  172.     END;
  173.     PPCInformPBPtr = ^PPCInformPBRec;
  174.  
  175.     PPCStartPBRec = PACKED RECORD
  176.         qLink:                    Ptr;
  177.         csCode:                    INTEGER;
  178.         intUse:                    INTEGER;
  179.         intUsePtr:                Ptr;
  180.         ioCompletion:            PPCCompUPP;
  181.         ioResult:                OSErr;
  182.         Reserved:                ARRAY [0..4] OF LONGINT;
  183.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  184.         sessRefNum:                PPCSessRefNum;                            { 40 <--   Session Reference }
  185.         serviceType:            PPCServiceType;                            { 44 <--   Actual service method (realTime) }
  186.         resFlag:                UInt8;                                    { 45 -->   Must be set to 0  }
  187.         portName:                PPCPortPtr;                                { 46 -->   Destination portName }
  188.         locationName:            LocationNamePtr;                        { 50 -->   NBP or NAS style service location name }
  189.         rejectInfo:                LONGINT;                                { 54 <--   reason for rejecting the session request }
  190.         userData:                LONGINT;                                { 58 -->   Copied to destination PPCInform parameter block }
  191.         userRefNum:                LONGINT;                                { 62 -->   userRefNum (obtained during login process)  }
  192.     END;
  193.     PPCStartPBPtr = ^PPCStartPBRec;
  194.  
  195.     PPCAcceptPBRec = RECORD
  196.         qLink:                    Ptr;
  197.         csCode:                    INTEGER;
  198.         intUse:                    INTEGER;
  199.         intUsePtr:                Ptr;
  200.         ioCompletion:            PPCCompUPP;
  201.         ioResult:                OSErr;
  202.         Reserved:                ARRAY [0..4] OF LONGINT;
  203.         filler1:                INTEGER;
  204.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  205.     END;
  206.     PPCAcceptPBPtr = ^PPCAcceptPBRec;
  207.  
  208.     PPCRejectPBRec = RECORD
  209.         qLink:                    Ptr;
  210.         csCode:                    INTEGER;
  211.         intUse:                    INTEGER;
  212.         intUsePtr:                Ptr;
  213.         ioCompletion:            PPCCompUPP;
  214.         ioResult:                OSErr;
  215.         Reserved:                ARRAY [0..4] OF LONGINT;
  216.         filler1:                INTEGER;
  217.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  218.         filler2:                INTEGER;
  219.         filler3:                LONGINT;
  220.         filler4:                LONGINT;
  221.         rejectInfo:                LONGINT;                                { 54 -->   reason for rejecting the session request  }
  222.     END;
  223.     PPCRejectPBPtr = ^PPCRejectPBRec;
  224.  
  225.     PPCWritePBRec = RECORD
  226.         qLink:                    Ptr;
  227.         csCode:                    INTEGER;
  228.         intUse:                    INTEGER;
  229.         intUsePtr:                Ptr;
  230.         ioCompletion:            PPCCompUPP;
  231.         ioResult:                OSErr;
  232.         Reserved:                ARRAY [0..4] OF LONGINT;
  233.         filler1:                INTEGER;
  234.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  235.         bufferLength:            Size;                                    { 44 -->   Length of the message buffer }
  236.         actualLength:            Size;                                    { 48 <--   Actual Length Written }
  237.         bufferPtr:                Ptr;                                    { 52 -->   Pointer to message buffer }
  238.         more:                    BOOLEAN;                                { 56 -->   if more data in this block will be written }
  239.         filler2:                SInt8;
  240.         userData:                LONGINT;                                { 58 -->   Message block userData Uninterpreted by PPC }
  241.         blockCreator:            OSType;                                    { 62 -->   Message block creator Uninterpreted by PPC }
  242.         blockType:                OSType;                                    { 66 -->   Message block type Uninterpreted by PPC }
  243.     END;
  244.     PPCWritePBPtr = ^PPCWritePBRec;
  245.  
  246.     PPCReadPBRec = RECORD
  247.         qLink:                    Ptr;
  248.         csCode:                    INTEGER;
  249.         intUse:                    INTEGER;
  250.         intUsePtr:                Ptr;
  251.         ioCompletion:            PPCCompUPP;
  252.         ioResult:                OSErr;
  253.         Reserved:                ARRAY [0..4] OF LONGINT;
  254.         filler1:                INTEGER;
  255.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  256.         bufferLength:            Size;                                    { 44 -->   Length of the message buffer }
  257.         actualLength:            Size;                                    { 48 <--   Actual length read }
  258.         bufferPtr:                Ptr;                                    { 52 -->   Pointer to message buffer }
  259.         more:                    BOOLEAN;                                { 56 <--   if true more data in this block to be read }
  260.         filler2:                SInt8;
  261.         userData:                LONGINT;                                { 58 <--   Message block userData Uninterpreted by PPC }
  262.         blockCreator:            OSType;                                    { 62 <--   Message block creator Uninterpreted by PPC }
  263.         blockType:                OSType;                                    { 66 <--   Message block type Uninterpreted by PPC }
  264.     END;
  265.     PPCReadPBPtr = ^PPCReadPBRec;
  266.  
  267.     PPCEndPBRec = RECORD
  268.         qLink:                    Ptr;
  269.         csCode:                    INTEGER;
  270.         intUse:                    INTEGER;
  271.         intUsePtr:                Ptr;
  272.         ioCompletion:            PPCCompUPP;
  273.         ioResult:                OSErr;
  274.         Reserved:                ARRAY [0..4] OF LONGINT;
  275.         filler1:                INTEGER;
  276.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  277.     END;
  278.     PPCEndPBPtr = ^PPCEndPBRec;
  279.  
  280.     PPCClosePBRec = RECORD
  281.         qLink:                    Ptr;
  282.         csCode:                    INTEGER;
  283.         intUse:                    INTEGER;
  284.         intUsePtr:                Ptr;
  285.         ioCompletion:            PPCCompUPP;
  286.         ioResult:                OSErr;
  287.         Reserved:                ARRAY [0..4] OF LONGINT;
  288.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  289.     END;
  290.     PPCClosePBPtr = ^PPCClosePBRec;
  291.  
  292.     IPCListPortsPBRec = RECORD
  293.         qLink:                    Ptr;
  294.         csCode:                    INTEGER;
  295.         intUse:                    INTEGER;
  296.         intUsePtr:                Ptr;
  297.         ioCompletion:            PPCCompUPP;
  298.         ioResult:                OSErr;
  299.         Reserved:                ARRAY [0..4] OF LONGINT;
  300.         filler1:                INTEGER;
  301.         startIndex:                INTEGER;                                { 40 -->   Start Index }
  302.         requestCount:            INTEGER;                                { 42 -->   Number of entries to be returned }
  303.         actualCount:            INTEGER;                                { 44 <--   Actual Number of entries to be returned }
  304.         portName:                PPCPortPtr;                                { 46 -->   PortName Match }
  305.         locationName:            LocationNamePtr;                        { 50 -->   NBP or NAS type name to locate the Port Location }
  306.         bufferPtr:                PortInfoArrayPtr;                        { 54 -->   Pointer to a buffer requestCount*sizeof(PortInfo) bytes big }
  307.     END;
  308.     IPCListPortsPBPtr = ^IPCListPortsPBRec;
  309.  
  310.     PPCParamBlockRec = RECORD
  311.         CASE INTEGER OF
  312.         0: (
  313.             openParam:                    PPCOpenPBRec;
  314.            );
  315.         1: (
  316.             informParam:                PPCInformPBRec;
  317.            );
  318.         2: (
  319.             startParam:                    PPCStartPBRec;
  320.            );
  321.         3: (
  322.             acceptParam:                PPCAcceptPBRec;
  323.            );
  324.         4: (
  325.             rejectParam:                PPCRejectPBRec;
  326.            );
  327.         5: (
  328.             writeParam:                    PPCWritePBRec;
  329.            );
  330.         6: (
  331.             readParam:                    PPCReadPBRec;
  332.            );
  333.         7: (
  334.             endParam:                    PPCEndPBRec;
  335.            );
  336.         8: (
  337.             closeParam:                    PPCClosePBRec;
  338.            );
  339.         9: (
  340.             listPortsParam:                IPCListPortsPBRec;
  341.            );
  342.     END;
  343.  
  344.  
  345. FUNCTION PPCInit: OSErr;
  346.     {$IFC NOT GENERATINGCFM}
  347.     INLINE $7000, $A0DD, $3E80;
  348.     {$ENDC}
  349. FUNCTION PPCOpen(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  350. FUNCTION PPCOpenSync(pb: PPCOpenPBPtr): OSErr;
  351.     {$IFC NOT GENERATINGCFM}
  352.     INLINE $205F, $7001, $A0DD, $3E80;
  353.     {$ENDC}
  354. FUNCTION PPCOpenAsync(pb: PPCOpenPBPtr): OSErr;
  355.     {$IFC NOT GENERATINGCFM}
  356.     INLINE $205F, $7001, $A4DD, $3E80;
  357.     {$ENDC}
  358. FUNCTION PPCInform(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  359. FUNCTION PPCInformSync(pb: PPCInformPBPtr): OSErr;
  360.     {$IFC NOT GENERATINGCFM}
  361.     INLINE $205F, $7003, $A0DD, $3E80;
  362.     {$ENDC}
  363. FUNCTION PPCInformAsync(pb: PPCInformPBPtr): OSErr;
  364.     {$IFC NOT GENERATINGCFM}
  365.     INLINE $205F, $7003, $A4DD, $3E80;
  366.     {$ENDC}
  367. FUNCTION PPCStart(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  368. FUNCTION PPCStartSync(pb: PPCStartPBPtr): OSErr;
  369.     {$IFC NOT GENERATINGCFM}
  370.     INLINE $205F, $7002, $A0DD, $3E80;
  371.     {$ENDC}
  372. FUNCTION PPCStartAsync(pb: PPCStartPBPtr): OSErr;
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $205F, $7002, $A4DD, $3E80;
  375.     {$ENDC}
  376. FUNCTION PPCAccept(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  377. FUNCTION PPCAcceptSync(pb: PPCAcceptPBPtr): OSErr;
  378.     {$IFC NOT GENERATINGCFM}
  379.     INLINE $205F, $7004, $A0DD, $3E80;
  380.     {$ENDC}
  381. FUNCTION PPCAcceptAsync(pb: PPCAcceptPBPtr): OSErr;
  382.     {$IFC NOT GENERATINGCFM}
  383.     INLINE $205F, $7004, $A4DD, $3E80;
  384.     {$ENDC}
  385. FUNCTION PPCReject(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  386. FUNCTION PPCRejectSync(pb: PPCRejectPBPtr): OSErr;
  387.     {$IFC NOT GENERATINGCFM}
  388.     INLINE $205F, $7005, $A0DD, $3E80;
  389.     {$ENDC}
  390. FUNCTION PPCRejectAsync(pb: PPCRejectPBPtr): OSErr;
  391.     {$IFC NOT GENERATINGCFM}
  392.     INLINE $205F, $7005, $A4DD, $3E80;
  393.     {$ENDC}
  394. FUNCTION PPCWrite(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  395. FUNCTION PPCWriteSync(pb: PPCWritePBPtr): OSErr;
  396.     {$IFC NOT GENERATINGCFM}
  397.     INLINE $205F, $7006, $A0DD, $3E80;
  398.     {$ENDC}
  399. FUNCTION PPCWriteAsync(pb: PPCWritePBPtr): OSErr;
  400.     {$IFC NOT GENERATINGCFM}
  401.     INLINE $205F, $7006, $A4DD, $3E80;
  402.     {$ENDC}
  403. FUNCTION PPCRead(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  404. FUNCTION PPCReadSync(pb: PPCReadPBPtr): OSErr;
  405.     {$IFC NOT GENERATINGCFM}
  406.     INLINE $205F, $7007, $A0DD, $3E80;
  407.     {$ENDC}
  408. FUNCTION PPCReadAsync(pb: PPCReadPBPtr): OSErr;
  409.     {$IFC NOT GENERATINGCFM}
  410.     INLINE $205F, $7007, $A4DD, $3E80;
  411.     {$ENDC}
  412. FUNCTION PPCEnd(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  413. FUNCTION PPCEndSync(pb: PPCEndPBPtr): OSErr;
  414.     {$IFC NOT GENERATINGCFM}
  415.     INLINE $205F, $7008, $A0DD, $3E80;
  416.     {$ENDC}
  417. FUNCTION PPCEndAsync(pb: PPCEndPBPtr): OSErr;
  418.     {$IFC NOT GENERATINGCFM}
  419.     INLINE $205F, $7008, $A4DD, $3E80;
  420.     {$ENDC}
  421. FUNCTION PPCClose(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  422. FUNCTION PPCCloseSync(pb: PPCClosePBPtr): OSErr;
  423.     {$IFC NOT GENERATINGCFM}
  424.     INLINE $205F, $7009, $A0DD, $3E80;
  425.     {$ENDC}
  426. FUNCTION PPCCloseAsync(pb: PPCClosePBPtr): OSErr;
  427.     {$IFC NOT GENERATINGCFM}
  428.     INLINE $205F, $7009, $A4DD, $3E80;
  429.     {$ENDC}
  430. FUNCTION IPCListPorts(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  431. FUNCTION IPCListPortsSync(pb: IPCListPortsPBPtr): OSErr;
  432.     {$IFC NOT GENERATINGCFM}
  433.     INLINE $205F, $700A, $A0DD, $3E80;
  434.     {$ENDC}
  435. FUNCTION IPCListPortsAsync(pb: IPCListPortsPBPtr): OSErr;
  436.     {$IFC NOT GENERATINGCFM}
  437.     INLINE $205F, $700A, $A4DD, $3E80;
  438.     {$ENDC}
  439. FUNCTION DeleteUserIdentity(userRef: LONGINT): OSErr;
  440. FUNCTION GetDefaultUser(VAR userRef: LONGINT; VAR userName: Str32): OSErr;
  441. FUNCTION StartSecureSession(pb: PPCStartPBPtr; VAR userName: Str32; useDefault: BOOLEAN; allowGuest: BOOLEAN; VAR guestSelected: BOOLEAN; prompt: ConstStr255Param): OSErr;
  442. TYPE
  443.     PPCFilterProcPtr = ProcPtr;  { FUNCTION PPCFilter(name: LocationNamePtr; port: PortInfoPtr): BOOLEAN; }
  444.     PPCFilterUPP = UniversalProcPtr;
  445.  
  446. CONST
  447.     uppPPCCompProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  448.     uppPPCFilterProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }
  449.  
  450. FUNCTION NewPPCCompProc(userRoutine: PPCCompProcPtr): PPCCompUPP;
  451.     {$IFC NOT GENERATINGCFM }
  452.     INLINE $2E9F;
  453.     {$ENDC}
  454.  
  455. FUNCTION NewPPCFilterProc(userRoutine: PPCFilterProcPtr): PPCFilterUPP;
  456.     {$IFC NOT GENERATINGCFM }
  457.     INLINE $2E9F;
  458.     {$ENDC}
  459.  
  460. PROCEDURE CallPPCCompProc(pb: PPCParamBlockPtr; userRoutine: PPCCompUPP);
  461.     {$IFC NOT GENERATINGCFM}
  462.     INLINE $205F, $4E90;
  463.     {$ENDC}
  464.  
  465. FUNCTION CallPPCFilterProc(name: LocationNamePtr; port: PortInfoPtr; userRoutine: PPCFilterUPP): BOOLEAN;
  466.     {$IFC NOT GENERATINGCFM}
  467.     INLINE $205F, $4E90;
  468.     {$ENDC}
  469.  
  470. FUNCTION PPCBrowser(prompt: ConstStr255Param; applListLabel: ConstStr255Param; defaultSpecified: BOOLEAN; VAR theLocation: LocationNameRec; VAR thePortInfo: PortInfoRec; portFilter: PPCFilterUPP; theLocNBPType: ConstStr32Param): OSErr;
  471.     {$IFC NOT GENERATINGCFM}
  472.     INLINE $303C, $0D00, $A82B;
  473.     {$ENDC}
  474.  
  475. {$ALIGN RESET}
  476. {$POP}
  477.  
  478. {$SETC UsingIncludes := PPCToolboxIncludes}
  479.  
  480. {$ENDC} {__PPCTOOLBOX__}
  481.  
  482. {$IFC NOT UsingIncludes}
  483.  END.
  484. {$ENDC}
  485.